home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / libs / sphigs / sph_mac.hqx / SRGP port to 5.0 (compressed) / SRGP_SPHIGS Root / MacSRGP / srgp_state.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-13  |  5.2 KB  |  260 lines
  1. #include "HEADERS.h"
  2. #define SRGP_BOSS
  3. #include "srgplocal.h"
  4.  
  5. #include "srgp_state.proto.h"
  6. static void InitSRGP(char *, int, int, int, boolean);
  7. static boolean CheckNotEnabledYet(void);
  8.  
  9. static char message[] =  "Unable to open the SRGP logfile!";
  10.  
  11. int SRGP_errorOccurred = 0;
  12.  
  13. errorHandlingMode srgp__curErrHndlMode = FATAL_ERRORS;
  14.  
  15.  
  16.  
  17. /** SRGP_tracing
  18. **/
  19. void
  20. SRGP_tracing (boolean please_trace)
  21. {
  22.  
  23.    if ( ! SRGP_logStream) {
  24.       /* LOGGING FILE IN LINE-BUFFERED MODE. */
  25.       if (SRGP_logStream = fopen ("SRGPlogfile", "w")) 
  26. #ifdef sun
  27.      setvbuf (SRGP_logStream, NULL, _IOLBF, 512);
  28. #else
  29.       {}
  30. #endif
  31.       else {
  32. #ifdef THINK_C
  33.      ReportSpecialError (message, NON_FATAL);
  34.          return;  /* we can't enable it, but we can continue! */
  35. #else
  36.      fprintf (stderr, "%s\n", message);
  37.      exit (1);
  38. #endif
  39.       }
  40.    }
  41.  
  42.    SRGP_trace (SRGP_logStream, "---- TRACE DISABLED\n");
  43.    srgp__traceDisabled = ! please_trace;
  44.    SRGP_trace (SRGP_logStream, "++++ TRACE ENABLED\n");
  45. }
  46.  
  47.  
  48. void
  49. SRGP_disableDebugAids (void)
  50. {
  51.    srgp__userDebugAidsDisabled = TRUE;
  52. }
  53.  
  54.  
  55. void
  56. SRGP_enableBlockedWait (void)
  57. {
  58.    srgp__blockedWaitEnabled = TRUE;
  59. }
  60.  
  61.  
  62.  
  63. static void
  64. InitSRGP (char *name, int width, int height, int requested_planes, boolean debugasap)
  65. {
  66.    register cnt;
  67.    
  68.    
  69.    unlink ("./SRGPlogfile");
  70.  
  71.    ALLOC_RECORDS (srgp__bitmapPatternTable, pattern_table_entry, MAX_PATTERN_INDEX+1);
  72.    ALLOC_RECORDS (srgp__pixmapPatternTable, pixpat_table_entry, MAX_PATTERN_INDEX+1);
  73.    ALLOC_RECORDS (srgp__fontTable, fontInfo, MAX_FONT_INDEX+1);
  74.    ALLOC_RECORDS (srgp__cursorTable, cursorInfo, MAX_CURSOR_INDEX+1);
  75.    ALLOC_RECORDS (srgp__canvasTable, canvas_spec, MAX_CANVAS_INDEX+1);
  76. #ifdef X11
  77.    ALLOC_RECORDS (Xformat_vertices, XPoint, MAX_POINTLIST_SIZE);
  78. #endif
  79.  
  80.    
  81.    srgp__curActiveCanvasId = 0;
  82.    srgp__curActiveCanvasSpec.max_xcoord = (width-1);
  83.    srgp__curActiveCanvasSpec.max_ycoord = (height-1);
  84.    
  85.    SRGP__initGraphicsDevice (name, requested_planes, debugasap);
  86.  
  87.  
  88.    /*************** INIT. CANVAS TABLE TO SHOW THAT ONLY CANVAS 0 IS ALIVE */
  89.    srgp__canvasTable[0].drawable = srgp__curActiveCanvasSpec.drawable;
  90.    for (cnt=1; cnt <= MAX_CANVAS_INDEX; cnt++)
  91.       srgp__canvasTable[cnt].drawable.win = NULL;
  92.       
  93.    
  94.    SRGP__initCursorTable();
  95.  
  96.    SRGP__initDefaultPatterns();
  97.  
  98.    SRGP__initFont();
  99.  
  100.    SRGP__setCanvasDefaults();
  101.  
  102.    srgp__resizeCallback = NULL;
  103.  
  104.    /* INIT TRACING ET.AL. */
  105.    srgp__traceDisabled = TRUE;
  106.    SRGP_logStream = NULL;
  107.  
  108.    SRGP__initInputModule();
  109. }
  110.  
  111.  
  112.  
  113.  
  114. /*!*/
  115. void SRGP_beginWithDebug 
  116.    (char *name, int width, int height, int planes, boolean enable_trace)
  117. /* FOR USE BY SYSTEM ADMINS ONLY */
  118. {
  119.    if (srgp__enabled)
  120.       SRGP__error (ERR_ALREADY_ENABLED);
  121.    else {
  122.       srgp__enabled = TRUE;
  123.       InitSRGP (name, width, height, planes, TRUE);
  124.    }
  125.  
  126.    if (enable_trace) 
  127.       SRGP_tracing (TRUE);
  128. }
  129.  
  130.  
  131. /*!*/
  132. void SRGP_begin 
  133.    (char *name, int width, int height, int planes, boolean enable_trace)
  134. {
  135.    if (srgp__enabled)
  136.       SRGP__error (ERR_ALREADY_ENABLED);
  137.    else {
  138.       srgp__enabled = TRUE;
  139.       InitSRGP (name, width, height, planes, FALSE);
  140.    }
  141.  
  142.    if (enable_trace) 
  143.       SRGP_tracing (TRUE);
  144. }
  145.  
  146.  
  147. /*!*/
  148. /* JJR resizeCall => PortSize */
  149. void SRGP_registerResizeCallback (funcptr PortSize)
  150. {
  151.    srgp__resizeCallback = PortSize;
  152. }
  153.  
  154.  
  155.  
  156. /*!*/
  157. void SRGP_end (void)
  158. {
  159.    SRGP_trace (SRGP_logStream, "SRGP_end\n");
  160.    
  161. #  ifdef THINK_C
  162.    SRGP__cleanupMacMemory();
  163.    DisposeWindow (srgpmac__cwindow);
  164. #  endif
  165.  
  166.    srgp__enabled = FALSE;
  167.    if (SRGP_logStream)
  168.       fclose (SRGP_logStream);
  169. }
  170.  
  171.  
  172.  
  173. void SRGP_setErrorHandlingMode (errorHandlingMode newmode)
  174. {
  175.    srgp__curErrHndlMode = newmode;
  176. }
  177.  
  178.  
  179. /** ROUTINES ALLOWING APPLICATION TO CHANGE SIZES OF TABLES
  180. These may only be called *before* SRGP is enabled.
  181. **/
  182.  
  183. static boolean CheckNotEnabledYet (void)
  184. {
  185.    if (srgp__enabled) {
  186.       SRGP__error (ERR_ALREADY_ENABLED);
  187.       return FALSE;
  188.    }
  189.    else
  190.       return TRUE;
  191. }
  192.  
  193.  
  194. void SRGP_setMaxCanvasIndex (int i)
  195. {
  196. if (CheckNotEnabledYet())
  197.    MAX_CANVAS_INDEX = i;
  198. }
  199.  
  200. void SRGP_setMaxPatternIndex (int i)
  201. {
  202. if (CheckNotEnabledYet())
  203.    MAX_PATTERN_INDEX = i;
  204. }
  205.  
  206. void SRGP_setMaxCursorIndex (int i)
  207. {
  208. if (CheckNotEnabledYet())
  209.    MAX_CURSOR_INDEX = i;
  210. }
  211.  
  212. void SRGP_setMaxFontIndex (int i)
  213. {
  214. if (CheckNotEnabledYet())
  215.    MAX_FONT_INDEX = i;
  216. }
  217.  
  218. void SRGP_setMaxPointlistSize (int i)
  219. {
  220. if (CheckNotEnabledYet())
  221.    MAX_POINTLIST_SIZE = i;
  222. }
  223.  
  224. void SRGP_setMaxStringSize (int i)
  225. {
  226. if (CheckNotEnabledYet())
  227.    MAX_STRING_SIZE = i;
  228. }
  229.  
  230.  
  231.  
  232. void
  233. SRGP__reactToScreenResize (int www, int hhh)
  234. {
  235.    if (srgp__curActiveCanvasId == 0)
  236.       srgp__canvasTable[0] = srgp__curActiveCanvasSpec;
  237.  
  238.    srgp__canvasTable[0].max_xcoord = www - 1;
  239.    srgp__canvasTable[0].max_ycoord = hhh - 1;
  240.  
  241.    if (srgp__curActiveCanvasId == 0)
  242.       srgp__curActiveCanvasSpec = srgp__canvasTable[0];
  243.    
  244.    /* The locator measure needs to be updated, since its y coord is a
  245.       function of the max_ycoord of the screen canvas. */
  246.    srgp__cur_locator_measure.position.y =
  247.       srgp__canvasTable[0].max_ycoord - srgp__cur_Xcursor_y;
  248.    
  249.    if (srgp__resizeCallback)
  250.       (*srgp__resizeCallback) (www, hhh);
  251. }
  252.  
  253.  
  254. void
  255. SRGP_changeScreenCanvasSize (int newwidth, int newheight)
  256. {
  257.    SRGP__forceScreenResize (newwidth, newheight);
  258.    SRGP__reactToScreenResize (newwidth, newheight);
  259. }
  260.